
import pandas as pd
import numpy as np
import pylab as plt
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
import statistics  as sts
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import KFold
from sklearn.manifold import TSNE
from sklearn.metrics import accuracy_score, confusion_matrix,roc_curve, auc
import matplotlib.patches as mpatches
from matplotlib.legend import Legend
from sklearn.tree import plot_tree
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import StratifiedKFold

# Ignorer warnings
warnings.filterwarnings("ignore")


df_data = pd.read_csv('train_titanic.csv')
df_data.head()


df_data.dtypes

PassengerId      int64
Survived         int64
Pclass           int64
Name            object
Sex             object
Age            float64
SibSp            int64
Parch            int64
Ticket          object
Fare           float64
Cabin           object
Embarked        object
dtype: object


df_data.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 12 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   PassengerId  891 non-null    int64  
 1   Survived     891 non-null    int64  
 2   Pclass       891 non-null    int64  
 3   Name         891 non-null    object 
 4   Sex          891 non-null    object 
 5   Age          714 non-null    float64
 6   SibSp        891 non-null    int64  
 7   Parch        891 non-null    int64  
 8   Ticket       891 non-null    object 
 9   Fare         891 non-null    float64
 10  Cabin        204 non-null    object 
 11  Embarked     889 non-null    object 
dtypes: float64(2), int64(5), object(5)
memory usage: 83.7+ KB


df_data['Survived'].value_counts().plot.pie(autopct='%1.1f%%',shadow=True,figsize=(10,5),colors=['orchid','mediumslateblue'])
plt.title('Pourcentage de survivants et de morts')
plt.legend(['Mort','Survivant'])
plt.show()


df_data.describe()


fig, axes = plt.subplots(2, 3, figsize=(18, 12))

# Rangée supérieure de graphiques
# Graphique de l'âge
sns.histplot(data=df_data, x='Age', bins=20, color='#008080', ax=axes[0, 0])
axes[0, 0].set_xlabel('Âge')
axes[0, 0].set_ylabel('Nombre de passagers')
axes[0, 0].set_title('Distribution de l\'âge des passagers')

# Graphique de la classe des passagers (Pclass)
class_counts = df_data['Pclass'].value_counts()
sns.barplot(x=class_counts.index, y=class_counts.values, color='#CD5C5C', ax=axes[0, 1])
axes[0, 1].set_xlabel('Classe')
axes[0, 1].set_ylabel('Nombre de passagers')
axes[0, 1].set_title('Répartition des passagers par classe')
axes[0, 1].set_xticklabels(['1ère Classe', '2ème Classe', '3ème Classe'])

# Graphique de fare
sns.histplot(data=df_data, x='Fare', bins=20, color='#4169E1', ax=axes[0, 2])
axes[0, 2].set_xlabel('Tarif (Fare)')
axes[0, 2].set_ylabel('Nombre de passagers')
axes[0, 2].set_title('Distribution des tarifs des passagers')

# Rangée inférieure de graphiques
# Diagramme en boîte de l'âge
sns.boxplot(data=df_data, y='Age', color='#008080', ax=axes[1, 0])
axes[1, 0].set_xlabel('Âge')
axes[1, 0].set_title('Diagramme en boîte de l\'âge')

sns.boxplot(data=df_data, x='Pclass', y='Fare', color='#CD5C5C', ax=axes[1, 1])
axes[1, 1].set_xlabel('Classe')
axes[1, 1].set_ylabel('Tarif (Fare)')
axes[1, 1].set_title('Diagramme en boîte du tarif des tickets par classe')
axes[1, 1].set_xticklabels(['1ère Classe', '2ème Classe', '3ème Classe'])

# Diagramme en boîte de Fare
sns.boxplot(data=df_data, y='Fare', color='#4169E1', ax=axes[1, 2])
axes[1, 2].set_xlabel('Tarif (Fare)')
axes[1, 2].set_title('Diagramme en boîte du tarif des tickets')

plt.tight_layout()
plt.show()


plt.figure(figsize=(15, 5))
custom_palette = sns.color_palette("flare", as_cmap=True)
sns.heatmap(df_data.corr(), annot=True, cmap=custom_palette)

<Axes: >


# graphique histogramme qui permet de visualiser la distribution des survivants et morts par rapport aux tarifs des tickets.
plt.figure(figsize=(15, 5))
plt.xlim(0, df_data['Fare'].max() + 20)
plt.yticks(np.arange(0, 500, 25))

sns.histplot(data=df_data, x='Fare', hue='Survived', bins=45, palette=['green','red'],alpha=0.5,multiple='stack')
plt.title('Distribution des tarifs des passagers en fonction de la survie')
plt.xlabel('Tarif (Fare)')
plt.ylabel('Nombre de passagers')
plt.legend(['Survivant','Mort'])
plt.show()


df_data = df_data.drop (['Name','PassengerId','Ticket'], axis = 1)


# Vérifier si la colonne Cabin existe, et si c'est le cas, nous la supprimons
if 'Cabin' in df_data.columns:
    df_data = df_data.drop (['Cabin'], axis = 1)

# Remplacement des valeurs manquantes dans la colonne Age par la médiane
median_age = df_data['Age'].median()
df_data['Age'].fillna(median_age, inplace=True)

# Remplacement des valeurs manquantes dans la colonne Embarked par la valeur la plus fréquente
most_frequent_embarked = df_data['Embarked'].value_counts().index[0]
df_data['Embarked'].fillna(most_frequent_embarked, inplace=True)

df_data.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 8 columns):
 #   Column    Non-Null Count  Dtype  
---  ------    --------------  -----  
 0   Survived  891 non-null    int64  
 1   Pclass    891 non-null    int64  
 2   Sex       891 non-null    object 
 3   Age       891 non-null    float64
 4   SibSp     891 non-null    int64  
 5   Parch     891 non-null    int64  
 6   Fare      891 non-null    float64
 7   Embarked  891 non-null    object 
dtypes: float64(2), int64(4), object(2)
memory usage: 55.8+ KB


df_data = pd.get_dummies(df_data, columns=["Sex", "Embarked"], prefix=["Sex", "Embarked"])


df_data.head()


std = StandardScaler()

columns = ['Age', 'Fare']
scaled = std.fit_transform(df_data[columns])

# Création d'un nouveau DataFrame avec les données mises à l'échelle
scaled = pd.DataFrame(scaled, columns=columns)

# Suppression des colonnes 'Age' et 'Fare' d'avant la mise a lechelle
df = df_data.drop(columns=columns, axis=1)

# Fusion des données mises à l'échelle avec le DataFrame d'origine
df = df.merge(scaled, left_index=True, right_index=True, how="left")

df.head()


#Selection de la colonne Survived pour définir notre vecteur de classes
y = df['Survived'].values

# ajouter un a chaque élement de y(pour avoir des classes de 1 et 2)
YR = y + 1

# On supprime la colonne y pour obtenir le vecteur X des variables descriptives
X = df.drop(['Survived'], axis=1).values

# On sépare notre base de données en base d'apprentissage et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
y_train += 1

K = int(np.max(YR))

# Fonction de perte L0-1
L = np.ones((K, K)) - np.eye(K)


# Projection de tous les points dans un espace de dimension 2
tsne = TSNE(n_components=2, verbose=0, random_state=123)
z = tsne.fit_transform(X)

dfTSNE = pd.DataFrame()
dfTSNE['y'] = YR
dfTSNE["comp-1"] = z[:,0]
dfTSNE["comp-2"] = z[:,1]

leg = ['Mort' if value == 1 else 'Survivant' for value in dfTSNE.y.tolist()]

sns.scatterplot(x="comp-1", y="comp-2", hue=leg,
                palette=sns.color_palette("hls", 2),
                data=dfTSNE).set(title="T-SNE projection")

[Text(0.5, 1.0, 'T-SNE projection')]


run functions.ipynb


from sklearn.linear_model import Lasso

lasso = Lasso()
search = GridSearchCV(estimator=lasso, param_grid={'alpha': np.logspace(-5, 2, 8)}, scoring='neg_mean_squared_error', n_jobs=1, refit=True, cv=10)

search.fit(X_train, y_train)

lasso = Lasso(alpha=search.best_params_['alpha'])
lasso.fit(X_train, y_train)

second = mean_squared_error(y_train, lasso.predict(X_train))

coef_dict_baseline = {}
for coef, feat in zip(lasso.coef_, df.columns):
    coef_dict_baseline[feat] = coef

plt.figure(figsize=(12, 6))
plt.bar(coef_dict_baseline.keys(), coef_dict_baseline.values())
plt.xticks(rotation=90)
plt.xlabel('Features')
plt.ylabel('Feature Importance')
plt.title('Feature Importance using Lasso Regression')
plt.show()


from sklearn.linear_model import Ridge

ridge = Ridge()
search = GridSearchCV(estimator=ridge, param_grid={'alpha': np.logspace(-5, 2, 8)}, scoring='neg_mean_squared_error', n_jobs=1, refit=True, cv=10)

search.fit(X_train, y_train)

ridge = Ridge(alpha=search.best_params_['alpha'])
ridge.fit(X_train, y_train)

second = mean_squared_error(y_train, ridge.predict(X_train))

coef_dict_baseline = {}
for coef, feat in zip(ridge.coef_, df.columns):
    coef_dict_baseline[feat] = coef

plt.figure(figsize=(12, 6))
plt.bar(coef_dict_baseline.keys(), coef_dict_baseline.values())
plt.xticks(rotation=90)
plt.xlabel('Features')
plt.ylabel('Feature Importance')
plt.title('Feature Importance using Ridge Regression')
plt.show()


from sklearn.neighbors import KNeighborsClassifier

np.random.seed(407)

nbFolds = 10
kf = KFold(n_splits=nbFolds, shuffle=True)
kfSplit = kf.split(X_train)

stock_kn = np.array([1, 10, 20, 30, 40, 50, 100])
nb_kn = stock_kn.shape[0]
stock_average_risk_Train = np.zeros((nbFolds, nb_kn))
stock_average_risk_Val = np.zeros((nbFolds, nb_kn))

min_diff_kn = None
min_diff = float('inf')

for f, (train, val) in enumerate(kfSplit):
    XTrain, XVal, YRTrain, YRVal = X_train[train, :], X_train[val, :], y_train[train], y_train[val]

    for t, kn in enumerate(stock_kn):
        model_KNN = KNeighborsClassifier(n_neighbors=kn, metric='euclidean')
        model_KNN.fit(XTrain, YRTrain.ravel())

        YhatTrainKNN = model_KNN.predict(XTrain)
        stock_average_risk_Train[f, t] = compute_average_risk(YRTrain, YhatTrainKNN, K, L)

        YhatValKNN = model_KNN.predict(XVal)
        stock_average_risk_Val[f, t] = compute_average_risk(YRVal, YhatValKNN, K, L)

        #Trouver la différence minimale entre les courbes d'entraînement et de validation.
        diff = abs(np.mean(stock_average_risk_Train, 0)[t] - np.mean(stock_average_risk_Val, 0)[t])
        if diff < min_diff:
            min_diff = diff
            min_diff_kn = kn


# Afficher les courbes d'erreur moyenne
plt.figure(figsize=(8, 6))
sns.lineplot(x=stock_kn, y=np.mean(stock_average_risk_Train, 0), label='Training', color='blue')
sns.lineplot(x=stock_kn, y=np.mean(stock_average_risk_Val, 0), label='Validation', color='orange')

plt.fill_between(stock_kn,
                 np.mean(stock_average_risk_Train, 0) - np.std(stock_average_risk_Train, 0),
                 np.mean(stock_average_risk_Train, 0) + np.std(stock_average_risk_Train, 0),
                 color='blue', alpha=0.2)

plt.fill_between(stock_kn,
                 np.mean(stock_average_risk_Val, 0) - np.std(stock_average_risk_Val, 0),
                 np.mean(stock_average_risk_Val, 0) + np.std(stock_average_risk_Val, 0),
                 color='orange', alpha=0.2)

# Trouver l'index avec la plus petite différence
min_diff_index = np.argmin(np.abs(np.mean(stock_average_risk_Train, 0) - np.mean(stock_average_risk_Val, 0)))
min_diff_kn = stock_kn[min_diff_index]

# Annoter le point où il y a la différence minimale
plt.annotate(f'Voisin Choisi: {min_diff_kn}',
             xy=(min_diff_kn, np.mean(stock_average_risk_Val, 0)[min_diff_index]),
             xytext=(min_diff_kn, np.mean(stock_average_risk_Val, 0)[min_diff_index] + 0.05),
             arrowprops=dict(facecolor='black', shrink=0.05),
             fontsize=10, ha='center')

plt.xlim(0, np.max(stock_kn))

plt.xlabel("Nombre de voisins", fontsize=14)
plt.ylabel("Risque d'erreur empirique", fontsize=14)
plt.title("Sélection du nombre de voisins optimal", fontsize=16)
plt.legend(fontsize=12, loc='lower right')
plt.xticks(fontsize=12)
plt.yticks(fontsize=12)
plt.grid(True)
plt.show()


nbFolds = 10
kf = KFold(n_splits=nbFolds, shuffle=True)
kfSplit = kf.split(X_train)

stock_average_risk_Train = np.zeros((nbFolds, 1))
stock_average_risk_Val = np.zeros((nbFolds, 1))

stock_RiskPerClass_Train = np.zeros((nbFolds, K))
stock_RiskPerClass_Val = np.zeros((nbFolds, K))

stock_Accuracy_Train = np.zeros(nbFolds)
stock_Accuracy_Val = np.zeros(nbFolds)

stock_AccPerClass_Train = np.zeros((nbFolds, K))
stock_AccPerClass_Val = np.zeros((nbFolds, K))

stock_ConfMat_Train = np.zeros((nbFolds, K, K))
stock_ConfMat_Val = np.zeros((nbFolds, K, K))

best_fold_XTrain = None
best_fold_YRTrain = None
best_fold_YhatTrainKNN = None
max_accuracy = 0.0

f = 0
kn = 20

for train, val in kfSplit:
    XTrain, XVal, YRTrain, YRVal = X_train[train, :], X_train[val, :], y_train[train], y_train[val]

    model_KNN = KNeighborsClassifier(n_neighbors=kn, metric='euclidean')
    model_KNN.fit(XTrain, YRTrain.ravel())

    YhatTrainKNN = model_KNN.predict(XTrain)

    stock_average_risk_Train[f, 0] = compute_average_risk(YRTrain, YhatTrainKNN, K, L)
    stock_RiskPerClass_Train[f, :] = compute_risk_per_class(YRTrain, YhatTrainKNN, K, L)
    stock_Accuracy_Train[f] = compute_accuracy(YRTrain, YhatTrainKNN)
    stock_AccPerClass_Train[f, :] = compute_accuracy_per_class(YRTrain, YhatTrainKNN, K)
    stock_ConfMat_Train[f, :, :] = compute_confusion_matrix(YRTrain, YhatTrainKNN, K)


    YhatValKNN = model_KNN.predict(XVal)
    stock_average_risk_Val[f, 0] = compute_average_risk(YRVal, YhatValKNN, K, L)
    stock_RiskPerClass_Val[f, :] = compute_risk_per_class(YRVal, YhatValKNN, K, L)
    stock_Accuracy_Val[f] = compute_accuracy(YRVal, YhatValKNN)
    stock_AccPerClass_Val[f, :] = compute_accuracy_per_class(YRVal, YhatValKNN, K)
    stock_ConfMat_Val[f, :, :] = compute_confusion_matrix(YRVal, YhatValKNN, K)



    accuracy_val = compute_accuracy(YRTrain, YhatTrainKNN)
    if accuracy_val > max_accuracy:
        max_accuracy = accuracy_val
        best_fold_XTrain = XTrain
        best_fold_YRTrain = YRTrain
        best_fold_YhatTrainKNN = YhatTrainKNN

    f = f + 1


# Afficher le risque moyen
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
sns.barplot(x=np.arange(nbFolds), y=stock_average_risk_Train.ravel(), color='blue', ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Average Risk - Training Set')
plt.xlabel('Fold')
plt.ylabel('Average Risk')

plt.subplot(1, 2, 2)
sns.barplot(x=np.arange(nbFolds), y=stock_average_risk_Val.ravel(), color='orange',ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Average Risk - Validation Set')
plt.xlabel('Fold')
plt.ylabel('Average Risk')

plt.tight_layout()
plt.show()

# Afficher l'accuarcy moyenne
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
sns.barplot(x=np.arange(nbFolds), y=stock_Accuracy_Train, color='blue', ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Average Accuracy - Training Set')
plt.xlabel('Fold')
plt.ylabel('Average Accuracy')


plt.subplot(1, 2, 2)
sns.barplot(x=np.arange(nbFolds), y=stock_Accuracy_Val, color='orange',ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Average Accuracy - Validation Set')
plt.xlabel('Fold')
plt.ylabel('Average Accuracy')

plt.tight_layout()
plt.show()

# Aficher risk per class
plt.figure(figsize=(12, 12))

# Subplot  Classe 0 - Training Set
plt.subplot(2, 2, 1)
sns.barplot(x=np.arange(nbFolds), y=stock_RiskPerClass_Train[:, 0], color='blue', ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Risk Per Class (Class 0) - Training Set')
plt.xlabel('Fold')
plt.ylabel('Risk')

# Subplot Classe 1 - Training Set
plt.subplot(2, 2, 3)
sns.barplot(x=np.arange(nbFolds), y=stock_RiskPerClass_Train[:, 1], color='blue', ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Risk Per Class (Class 1) - Training Set')
plt.xlabel('Fold')
plt.ylabel('Risk')

# Subplot Classe 0 - Validation Set
plt.subplot(2, 2, 2)
sns.barplot(x=np.arange(nbFolds), y=stock_RiskPerClass_Val[:, 0], color='orange', ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Risk Per Class (Class 0) - Validation Set')
plt.xlabel('Fold')
plt.ylabel('Risk')

# Subplot Classe 1 - Validation Set
plt.subplot(2, 2, 4)
sns.barplot(x=np.arange(nbFolds), y=stock_RiskPerClass_Val[:, 1], color='orange', ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Risk Per Class (Class 1) - Validation Set')
plt.xlabel('Fold')
plt.ylabel('Risk')

plt.tight_layout()
plt.show()




# Afficher la matrice de confusion moyenne
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
sns.heatmap(np.mean(stock_ConfMat_Train, 0), annot=True, cmap='Blues', fmt='g')
plt.title(f'Average Confusion Matrix - Training Set {np.mean(stock_Accuracy_Train):.4f}')
plt.xlabel('Predicted Class')
plt.ylabel('True Class')

plt.subplot(1, 2, 2)
sns.heatmap(np.mean(stock_ConfMat_Val, 0), annot=True, cmap='Oranges', fmt='g')
plt.title(f'Average Confusion Matrix - Validation Set {np.mean(stock_Accuracy_Val):.4f}')
plt.xlabel('Predicted Class')
plt.ylabel('True Class')

plt.tight_layout()
plt.show()


# TSNE projection - Ground Truth vs Predicted

plt.figure(figsize=(14, 6))

# Aficher Ground Truth
plt.subplot(1, 2, 1)

tsne = TSNE(n_components=2, verbose=0, random_state=42)
z = tsne.fit_transform(best_fold_XTrain)

df = pd.DataFrame()
df['y'] = best_fold_YRTrain
df["comp-1"] = z[:, 0]
df["comp-2"] = z[:, 1]

leg = ['Mort' if value == 1 else 'Survivant' for value in df.y.tolist()]

sns.scatterplot(x="comp-1", y="comp-2", hue=leg,
                palette=sns.color_palette("hls", 2),
                data=df).set(title="T-SNE projection - Ground Truth")

# Afficher Predicted
plt.subplot(1, 2, 2)

tsne = TSNE(n_components=2, verbose=0, random_state=42)
z = tsne.fit_transform(best_fold_XTrain)

df = pd.DataFrame()
df['y'] = best_fold_YhatTrainKNN
df["comp-1"] = z[:, 0]
df["comp-2"] = z[:, 1]

leg = ['Mort' if value == 1 else 'Survivant' for value in df.y.tolist()]

sns.scatterplot(x="comp-1", y="comp-2", hue=leg,
                palette=sns.color_palette("hls", 2),
                data=df).set(title="T-SNE projection - Predicted")

plt.tight_layout()
plt.show()


from sklearn.naive_bayes import GaussianNB


model_bayes = GaussianNB()
model_bayes.fit(X_train, y_train)

# Prédire les données de test
predictions_bayes = model_bayes.predict(X_test)
accuracy_bayes = accuracy_score(y_test, predictions_bayes)
conf_matrix_bayes = confusion_matrix(y_test, predictions_bayes)

# Apliquer le TSNE pour réduire à 2 dimensions
tsne = TSNE(n_components=2)
X_tsne = tsne.fit_transform(X)


model_bayes.fit(X_tsne, y)
predictions_bayes_tsne = model_bayes.predict(X_tsne)
accuracy_bayes_tsne = accuracy_score(y, predictions_bayes_tsne)
conf_matrix_bayes_tsne = confusion_matrix(y, predictions_bayes_tsne)

# Afficher les points
plt.figure(figsize=(10, 8))


sns.scatterplot(x=X_tsne[:, 0], y=X_tsne[:, 1], hue=predictions_bayes_tsne, palette='bwr', marker='o', legend=False)

# Afficher les frontières de décision
h = .02
x_min, x_max = X_tsne[:, 0].min() - 1, X_tsne[:, 0].max() + 1
y_min, y_max = X_tsne[:, 1].min() - 1, X_tsne[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
Z = model_bayes.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, cmap='bwr', alpha=0.3)

# Ajouter une légende
label2 = ['Mort' if label == 0 else 'Survivant' for label in y]
unique_labels = list(set(label2))
legend_labels = ['Mort' if label == unique_labels[0] else 'Survivant' for label in label2]


colors = {'Mort': 'blue', 'Survivant': 'red'}
legend_patches = [mpatches.Patch(color=colors[label], label=label) for label in set(legend_labels)]

legend = Legend(plt.gca(), legend_patches, labels=set(legend_labels), loc='upper right')
plt.gca().add_artist(legend)

plt.title(f'Bayes Naif avec t-SNE avec une précision de {accuracy_bayes_tsne:.2f}')
plt.xlabel('X 1')
plt.ylabel('X 2')
plt.show()


#Validation Croisée
nbFolds = 10
kf = KFold(n_splits=nbFolds, shuffle=True)
kfSplit = kf.split(X_train)

stock_average_risk_Train_bayes = np.zeros((nbFolds, 1))
stock_average_risk_Val_bayes = np.zeros((nbFolds, 1))

stock_RiskPerClass_Train_bayes = np.zeros((nbFolds, K))
stock_RiskPerClass_Val_bayes = np.zeros((nbFolds, K))

stock_Accuracy_Train_bayes = np.zeros(nbFolds)
stock_Accuracy_Val_bayes = np.zeros(nbFolds)

stock_AccPerClass_Train_bayes = np.zeros((nbFolds, K))
stock_AccPerClass_Val_bayes = np.zeros((nbFolds, K))

stock_ConfMat_Train_bayes = np.zeros((nbFolds, K, K))
stock_ConfMat_Val_bayes = np.zeros((nbFolds, K, K))

best_fold_XTrain = None
best_fold_YRTrain = None
best_fold_YhatTrainCBN = None
max_accuracy = 0.0

f = 0

for train, val in kfSplit:
    XTrain, XVal, YRTrain, YRVal = X_train[train, :], X_train[val, :], y_train[train], y_train[val]

    model_CBN = GaussianNB()
    model_CBN.fit(XTrain, YRTrain.ravel())

    # Prediction on the training samples
    YhatTrainCBN = model_CBN.predict(XTrain)
    stock_average_risk_Train_bayes[f, 0] = compute_average_risk(YRTrain, YhatTrainCBN, K, L)
    stock_RiskPerClass_Train_bayes[f, :] = compute_risk_per_class(YRTrain, YhatTrainCBN, K, L)
    stock_Accuracy_Train_bayes[f] = compute_accuracy(YRTrain, YhatTrainCBN)
    stock_AccPerClass_Train_bayes[f, :] = compute_accuracy_per_class(YRTrain, YhatTrainCBN, K)
    stock_ConfMat_Train_bayes[f, :, :] = compute_confusion_matrix(YRTrain, YhatTrainCBN, K)

    # Prediction on the testing samples
    YhatValCBN = model_CBN.predict(XVal)
    stock_average_risk_Val_bayes[f, 0] = compute_average_risk(YRVal, YhatValCBN, K, L)
    stock_RiskPerClass_Val_bayes[f, :] = compute_risk_per_class(YRVal, YhatValCBN, K, L)
    stock_Accuracy_Val_bayes[f] = compute_accuracy(YRVal, YhatValCBN)
    stock_AccPerClass_Val_bayes[f, :] = compute_accuracy_per_class(YRVal, YhatValCBN, K)
    stock_ConfMat_Val_bayes[f, :, :] = compute_confusion_matrix(YRVal, YhatValCBN, K)

    accuracy_val = compute_accuracy(YRTrain, YhatTrainCBN)
    if accuracy_val > max_accuracy:
        max_accuracy = accuracy_val
        best_fold_XTrain = XTrain
        best_fold_YRTrain = YRTrain
        best_fold_YhatTrainCBN = YhatTrainCBN

    f = f + 1

# Afficher le risque moyen
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
sns.barplot(x=np.arange(nbFolds), y=stock_average_risk_Train_bayes.ravel(), color='blue', ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Average Risk - Training Set')
plt.xlabel('Fold')
plt.ylabel('Average Risk')

plt.subplot(1, 2, 2)
sns.barplot(x=np.arange(nbFolds), y=stock_average_risk_Val_bayes.ravel(), color='orange',ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Average Risk - Validation Set')
plt.xlabel('Fold')
plt.ylabel('Average Risk')

plt.tight_layout()
plt.show()

# Afficher l'accuarcy moyenne
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
sns.barplot(x=np.arange(nbFolds), y=stock_Accuracy_Train_bayes, color='blue', ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Average Accuracy - Training Set')
plt.xlabel('Fold')
plt.ylabel('Average Accuracy')


plt.subplot(1, 2, 2)
sns.barplot(x=np.arange(nbFolds), y=stock_Accuracy_Val_bayes, color='orange',ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Average Accuracy - Validation Set')
plt.xlabel('Fold')
plt.ylabel('Average Accuracy')

plt.tight_layout()
plt.show()

# Aficher risk per class
plt.figure(figsize=(12, 12))

# Subplot  Classe 0 - Training Set
plt.subplot(2, 2, 1)
sns.barplot(x=np.arange(nbFolds), y=stock_RiskPerClass_Train_bayes[:, 0], color='blue', ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Risk Per Class (Class 0) - Training Set')
plt.xlabel('Fold')
plt.ylabel('Risk')

# Subplot Classe 1 - Training Set
plt.subplot(2, 2, 3)
sns.barplot(x=np.arange(nbFolds), y=stock_RiskPerClass_Train_bayes[:, 1], color='blue', ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Risk Per Class (Class 1) - Training Set')
plt.xlabel('Fold')
plt.ylabel('Risk')

# Subplot Classe 0 - Validation Set
plt.subplot(2, 2, 2)
sns.barplot(x=np.arange(nbFolds), y=stock_RiskPerClass_Val_bayes[:, 0], color='orange', ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Risk Per Class (Class 0) - Validation Set')
plt.xlabel('Fold')
plt.ylabel('Risk')

# Subplot Classe 1 - Validation Set
plt.subplot(2, 2, 4)
sns.barplot(x=np.arange(nbFolds), y=stock_RiskPerClass_Val_bayes[:, 1], color='orange', ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Risk Per Class (Class 1) - Validation Set')
plt.xlabel('Fold')
plt.ylabel('Risk')

plt.tight_layout()
plt.show()


# Afficher la matrice de confusion moyenne
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
sns.heatmap(np.mean(stock_ConfMat_Train_bayes, 0), annot=True, cmap='Blues', fmt='g')
plt.title(f'Average Confusion Matrix - Training Set {np.mean(stock_Accuracy_Train_bayes):.4f}')
plt.xlabel('Predicted Class')
plt.ylabel('True Class')

plt.subplot(1, 2, 2)
sns.heatmap(np.mean(stock_ConfMat_Val_bayes, 0), annot=True, cmap='Oranges', fmt='g')
plt.title(f'Average Confusion Matrix - Validation Set {np.mean(stock_Accuracy_Val_bayes):.4f}')
plt.xlabel('Predicted Class')
plt.ylabel('True Class')

plt.tight_layout()
plt.show()


from sklearn.manifold import TSNE

# Créer une palette HLS personnalisée
palette_hls_custom = sns.color_palette("hls", 2)

plt.figure(figsize=(14, 6))

# Afficher Ground Truth
plt.subplot(1, 2, 1)

tsne = TSNE(n_components=2, verbose=0, random_state=42)
z = tsne.fit_transform(best_fold_XTrain)

df = pd.DataFrame()
df['y'] = best_fold_YRTrain
df["comp-1"] = z[:, 0]
df["comp-2"] = z[:, 1]

# Inverser les couleurs pour le Ground Truth
leg_ground_truth = ['Survivant' if value == 1 else 'Mort' for value in df.y.tolist()]

sns.scatterplot(x="comp-1", y="comp-2", hue=leg_ground_truth,
                palette=palette_hls_custom,
                data=df).set(title="T-SNE projection - Ground Truth")

# Afficher Predicted
plt.subplot(1, 2, 2)

tsne = TSNE(n_components=2, verbose=0, random_state=42)
z = tsne.fit_transform(best_fold_XTrain)

df = pd.DataFrame()
df['y'] = best_fold_YhatTrainCBN
df["comp-1"] = z[:, 0]
df["comp-2"] = z[:, 1]

leg_predicted = ['Survivant' if value == 1 else 'Mort' for value in df.y.tolist()]

sns.scatterplot(x="comp-1", y="comp-2", hue=leg_predicted,
                palette=palette_hls_custom,
                data=df).set(title="T-SNE projection - Predicted")

plt.tight_layout()
plt.show()


from sklearn.linear_model import LogisticRegression


logistique_model = LogisticRegression(max_iter=1000, random_state=42)

logistique_model.fit(X_train, y_train)

# Faire des prédictions sur l'ensemble de test
predictions_rl = logistique_model.predict(X_test)

# Calculer l'accuracy et la matrice de confusion sur l'ensemble de test
accuracy_logistic = accuracy_score(y_test, predictions_rl)
conf_matrix_rl = confusion_matrix(y_test, predictions_rl)


# Appliquer t-SNE pour réduire à 2 dimensions
tsne = TSNE(n_components=2)
X_tsne = tsne.fit_transform(X)

logistique_model.fit(X_tsne, y)

predictions_rl_tsne = logistique_model.predict(X_tsne)
accuracy_logistic_tsne = accuracy_score(y, predictions_rl_tsne)
conf_matrix_rl_tsne = confusion_matrix(y, predictions_rl_tsne)

print(f'Accuracy du modèle Regression Logistique t-SNE: {accuracy_logistic_tsne:.2f}')


# Fonction pour tracer la frontière de décision
def plot_decision_boundary(model, X, y, ax, title):
    h = .02
    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
    Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)

    ax.contourf(xx, yy, Z, cmap='bwr', alpha=0.3)

# Fonction pour tracer les points de données
def plot_scatter(ax, X, predictions, title):
    scatter = ax.scatter(X[:, 0], X[:, 1], c=predictions, cmap='bwr', marker='o', label='Prédictions')

    # Créer une légende
    classes = ["Mort", "Survivant"]
    legend_labels = {i: label for i, label in enumerate(classes)}
    scatter_legend = plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='red', markersize=10, label=legend_labels[1])
    contour_legend = plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='blue', markersize=10, label=legend_labels[0])
    plt.legend(handles=[scatter_legend, contour_legend])

    ax.set_title(title)
    ax.set_xlabel('X 1')
    ax.set_ylabel('X 2')

# Afficher le graphique t-SNE avec la régression logistique
fig, ax = plt.subplots()

plot_decision_boundary(logistique_model, X_tsne, y, ax, 'Regression Logistique t-SNE')
plot_scatter(ax, X_tsne, predictions_rl_tsne, 'Regression Logistique t-SNE')

plt.tight_layout()
plt.show()

Accuracy du modèle Regression Logistique t-SNE: 0.77


from sklearn.linear_model import LogisticRegression


np.random.seed(407)

K = 2

nbFolds = 10
kf = KFold(n_splits=nbFolds, shuffle=True)
kfSplit = kf.split(X_train)

stock_average_risk_Train_rl = np.zeros((nbFolds, 1))
stock_average_risk_Val_rl = np.zeros((nbFolds, 1))

stock_RiskPerClass_Train_rl = np.zeros((nbFolds, K))
stock_RiskPerClass_Val_rl = np.zeros((nbFolds, K))

stock_Accuracy_Train_rl = np.zeros(nbFolds)
stock_Accuracy_Val_rl = np.zeros(nbFolds)

stock_AccPerClass_Train_rl = np.zeros((nbFolds, K))
stock_AccPerClass_Val_rl = np.zeros((nbFolds, K))

stock_ConfMat_Train_rl = np.zeros((nbFolds, K, K))
stock_ConfMat_Val_rl = np.zeros((nbFolds, K, K))

f = 0

for train, val in kfSplit:
    XTrain, XVal, YRTrain, YRVal = X_train[train, :], X_train[val, :], y_train[train], y_train[val]

    logistique_model = LogisticRegression(max_iter=1000, random_state=42)
    logistique_model.fit(XTrain, YRTrain)

    # Prediction sur les échantillons d'entraînement
    YhatTrain_lr = logistique_model.predict(XTrain)
    stock_average_risk_Train_rl[f, 0] = 1 - accuracy_score(YRTrain, YhatTrain_lr)
    stock_RiskPerClass_Train_rl[f, :] = 1 - accuracy_score(YRTrain, YhatTrain_lr, normalize=False) / np.sum(YRTrain == YRTrain)
    stock_Accuracy_Train_rl[f] = accuracy_score(YRTrain, YhatTrain_lr)
    stock_AccPerClass_Train_rl[f, :] = accuracy_score(YRTrain, YhatTrain_lr, normalize=False) / np.sum(YRTrain == YRTrain)
    stock_ConfMat_Train_rl[f, :, :] = confusion_matrix(YRTrain, YhatTrain_lr)

    # Prediction sur les échantillons de test
    YhatVal_lr = logistique_model.predict(XVal)
    stock_average_risk_Val_rl[f, 0] = 1 - accuracy_score(YRVal, YhatVal_lr)
    stock_RiskPerClass_Val_rl[f, :] = 1 - accuracy_score(YRVal, YhatVal_lr, normalize=False) / np.sum(YRVal == YRVal)
    stock_Accuracy_Val_rl[f] = accuracy_score(YRVal, YhatVal_lr)
    stock_AccPerClass_Val_rl[f, :] = accuracy_score(YRVal, YhatVal_lr, normalize=False) / np.sum(YRVal == YRVal)
    stock_ConfMat_Val_rl[f, :, :] = confusion_matrix(YRVal, YhatVal_lr)

    f = f + 1

# Plot average risk
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
sns.barplot(x=np.arange(nbFolds), y=stock_average_risk_Train_rl.ravel(), color='blue', ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Average Risk - Training Set')
plt.xlabel('Fold')
plt.ylabel('Average Risk')

plt.subplot(1, 2, 2)
sns.barplot(x=np.arange(nbFolds), y=stock_average_risk_Val_rl.ravel(), color='orange')
plt.title('Average Risk - Validation Set')
plt.xlabel('Fold')
plt.ylabel('Average Risk')

plt.tight_layout()
plt.show()

# Plot average accuracy
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
sns.barplot(x=np.arange(nbFolds), y=stock_Accuracy_Train_rl, color='blue', ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Average Accuracy - Training Set')
plt.xlabel('Fold')
plt.ylabel('Average Accuracy')

plt.subplot(1, 2, 2)
sns.barplot(x=np.arange(nbFolds), y=stock_Accuracy_Val_rl, color='orange')
plt.title('Average Accuracy - Validation Set')
plt.xlabel('Fold')
plt.ylabel('Average Accuracy')

plt.tight_layout()
plt.show()

# Heatmap average confusion matrix
labels = ['Class ' + str(i + 1) for i in range(K)]
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
conf_mat_train_avg = np.mean(stock_ConfMat_Train_rl, axis=0)
conf_mat_train_avg_percent = conf_mat_train_avg / conf_mat_train_avg.sum(axis=1, keepdims=True)
sns.heatmap(conf_mat_train_avg_percent, annot=True, fmt=".2f")
plt.title('Average Confusion Matrix - Training Set')

plt.subplot(1, 2, 2)
conf_mat_val_avg = np.mean(stock_ConfMat_Val_rl, axis=0)
conf_mat_val_avg_percent = conf_mat_val_avg / conf_mat_val_avg.sum(axis=1, keepdims=True)
sns.heatmap(conf_mat_val_avg_percent, annot=True, fmt=".2f")
plt.title('Average Confusion Matrix - Validation Set')

plt.tight_layout()
plt.show()


from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.model_selection import train_test_split, cross_val_score
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.manifold import TSNE


y_train = y_train.ravel() - 1

# Fit Decision Tree avec élagage
DT = DecisionTreeClassifier(random_state=0)
path = DT.cost_complexity_pruning_path(X_train, y_train)
ccp_alphas, impurities = path.ccp_alphas, path.impurities

# Compute risks versus Alpha
stocks_DT = []
stock_risk_train = []
stock_risk_test = []

for ccp_alpha in ccp_alphas:
    DT_alpha = DecisionTreeClassifier(random_state=0, ccp_alpha=ccp_alpha)
    DT_alpha.fit(X_train, y_train)
    stocks_DT.append(DT_alpha)
    # Risk Train DT :
    YhatTrain = DT_alpha.predict(X_train)
    stock_risk_train.append(1 - np.sum(y_train == YhatTrain) / len(y_train))
    # Risk Test DT :
    YhatTest = DT_alpha.predict(X_test)
    stock_risk_test.append(1 - np.sum(y_test == YhatTest) / len(y_test))

# Plot figure Risk versus Alpha
fig, ax = plt.subplots()
ax.set_xlabel("alpha")
ax.set_ylabel("Average risk")
ax.set_title("Average risk vs alpha for training and testing sets")
ax.plot(ccp_alphas, stock_risk_train, marker="o", label="train", drawstyle="steps-post")
ax.plot(ccp_alphas, stock_risk_test, marker="o", label="test", drawstyle="steps-post")
ax.legend()
plt.show()

# Entraîner le modèle d'arbre de décision avec le meilleur alpha
best_alpha = ccp_alphas[np.argmin(stock_risk_test)]
DT_elague = DecisionTreeClassifier(random_state=0, ccp_alpha=best_alpha)
DT_elague.fit(X_train, y_train)

# Vérification du nombre de feuilles terminales
nb_leaves = DT_elague.get_n_leaves()
print('Nb feuilles DT_elague =', nb_leaves)

# Visualiser l'arbre élagué
plt.figure(figsize=(12, 8))
plot_tree(DT_elague, filled=True, class_names=['Mort', 'Vivant'])
plt.show()




# Appliquer le t-SNE pour réduire à 2 dimensions
tsne = TSNE(n_components=2)
X_tsne = tsne.fit_transform(X_train)

# Entraîner le modèle d'arbre de décision élagué sur les données transformées par t-SNE
DT_elague.fit(X_tsne, y_train)

# Prédire avec le modèle élagué sur les données transformées par t-SNE
predictions_DT_elague_tsne = DT_elague.predict(X_tsne)
accuracy_DT_elague_tsne = accuracy_score(y_train, predictions_DT_elague_tsne)
conf_matrix_DT_elague_tsne = confusion_matrix(y_train, predictions_DT_elague_tsne)

print(f'Accuracy du modèle arbre de décision élagué avec t-SNE: {accuracy_DT_elague_tsne:.2f}')

# Tracer les points de données
plt.figure(figsize=(12, 8))
plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=predictions_DT_elague_tsne, cmap='bwr', marker='o', label='Prédictions')

# Tracer la frontière de décision avec des couleurs de fond
h = .02  # Pas de la grille
x_min, x_max = X_tsne[:, 0].min() - 1, X_tsne[:, 0].max() + 1
y_min, y_max = X_tsne[:, 1].min() - 1, X_tsne[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
Z = DT_elague.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

# Ajouter des couleurs de fond
plt.contourf(xx, yy, Z, cmap='bwr', alpha=0.3)

# Créer une légende personnalisée
classes = ["Mort", "Survivant"]
legend_labels = {i: label for i, label in enumerate(classes)}
scatter_legend = plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='red', markersize=10, label=legend_labels[1])
contour_legend = plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='blue', markersize=10, label=legend_labels[0])
plt.legend(handles=[scatter_legend, contour_legend])

plt.title('Arbre de décision élagué avec t-SNE')
plt.xlabel('t-SNE Dimension 1')
plt.ylabel('t-SNE Dimension 2')
plt.show()

Nb feuilles DT_elague = 7

Accuracy du modèle arbre de décision élagué avec t-SNE: 0.84


#arbre de decision avec critere de Gini comme condition d'arrêt



from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE
from sklearn.metrics import accuracy_score, confusion_matrix
import numpy as np

# Fit Decision Tree avec critère de Gini
DT = DecisionTreeClassifier(random_state=0, criterion='gini')
max_depths = np.arange(1, 21)  # Définir la plage de profondeurs maximales à explorer

# Initialiser des listes pour stocker les résultats
stocks_DT = []
stock_risk_train = []
stock_risk_test = []

for max_depth in max_depths:
    DT_depth = DecisionTreeClassifier(random_state=0, criterion='gini', max_depth=max_depth)
    DT_depth.fit(X_train, y_train)
    stocks_DT.append(DT_depth)

    # Risque sur l'ensemble d'entraînement
    YhatTrain = DT_depth.predict(X_train)
    stock_risk_train.append(1 - accuracy_score(y_train, YhatTrain))

    # Risque sur l'ensemble de test
    YhatTest = DT_depth.predict(X_test)
    stock_risk_test.append(1 - accuracy_score(y_test, YhatTest))

# Tracer figure Risque versus Profondeur Maximale
fig, ax = plt.subplots()
ax.set_xlabel("Profondeur Maximale")
ax.set_ylabel("Risque Moyen")
ax.set_title("Risque Moyen vs Profondeur Maximale pour les ensembles d'entraînement et de test")
ax.plot(max_depths, stock_risk_train, marker="o", label="Entraînement", drawstyle="steps-post")
ax.plot(max_depths, stock_risk_test, marker="o", label="Test", drawstyle="steps-post")
ax.legend()
plt.show()

# Sélectionner le modèle avec la meilleure profondeur maximale
best_depth = max_depths[np.argmin(stock_risk_test)]
DT_best_depth = DecisionTreeClassifier(random_state=0, criterion='gini', max_depth=best_depth)
DT_best_depth.fit(X_train, y_train)

# Vérifier le nombre de feuilles terminales
nb_leaves_best_depth = DT_best_depth.get_n_leaves()
print('Nombre de feuilles pour le meilleur modèle :', nb_leaves_best_depth)

# Visualiser l'arbre avec la meilleure profondeur maximale
plt.figure(figsize=(12, 8))
plot_tree(DT_best_depth, filled=True, class_names=['Mort', 'Vivant'])
plt.show()

# Appliquer le t-SNE pour réduire à 2 dimensions
tsne = TSNE(n_components=2)
X_tsne = tsne.fit_transform(X_train)

# Entraîner le modèle d'arbre de décision avec la meilleure profondeur maximale sur les données transformées par t-SNE
DT_best_depth.fit(X_tsne, y_train)

# Prédire avec le modèle sur les données transformées par t-SNE
predictions_DT_best_depth_tsne = DT_best_depth.predict(X_tsne)
accuracy_DT_best_depth_tsne = accuracy_score(y_train, predictions_DT_best_depth_tsne)
conf_matrix_DT_best_depth_tsne = confusion_matrix(y_train, predictions_DT_best_depth_tsne)

# Tracer les points de données
plt.figure(figsize=(12, 8))
plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=predictions_DT_best_depth_tsne, cmap='bwr', marker='o', label='Prédictions')

# Tracer la frontière de décision avec des couleurs de fond
h = .02  # Pas de la grille
x_min, x_max = X_tsne[:, 0].min() - 1, X_tsne[:, 0].max() + 1
y_min, y_max = X_tsne[:, 1].min() - 1, X_tsne[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
Z = DT_best_depth.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

# Ajouter des couleurs de fond
plt.contourf(xx, yy, Z, cmap='bwr', alpha=0.3)

# Créer une légende personnalisée
classes = ["Mort", "Survivant"]
legend_labels = {i: label for i, label in enumerate(classes)}
scatter_legend = plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='red', markersize=10, label=legend_labels[1])
contour_legend = plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='blue', markersize=10, label=legend_labels[0])
plt.legend(handles=[scatter_legend, contour_legend])

plt.title('Arbre de décision avec profondeur maximale optimale et t-SNE')
plt.xlabel('t-SNE Dimension 1')
plt.ylabel('t-SNE Dimension 2')
plt.show()

Nombre de feuilles pour le meilleur modèle : 15


from sklearn.tree import DecisionTreeClassifier

np.random.seed(407)

K = 2

nbFolds = 10
kf = KFold(n_splits=nbFolds, shuffle=True)
kfSplit = kf.split(X_train)

stock_Accuracy_Train_DT = np.zeros(nbFolds)
stock_Accuracy_Val_DT = np.zeros(nbFolds)

stock_Risk_Train_DT = np.zeros(nbFolds)
stock_Risk_Val_DT = np.zeros(nbFolds)

stock_ConfMat_Train_DT = np.zeros((nbFolds, K, K))
stock_ConfMat_Val_DT = np.zeros((nbFolds, K, K))

f = 0

for train, val in kfSplit:
    XTrain, XVal, YRTrain, YRVal = X_train[train, :], X_train[val, :], y_train[train], y_train[val]

    DT_model = DecisionTreeClassifier(random_state=0)
    DT_model.fit(XTrain, YRTrain)

    # Prediction sur les échantillons d'entraînement
    YhatTrain_DT = DT_model.predict(XTrain)
    stock_Accuracy_Train_DT[f] = accuracy_score(YRTrain, YhatTrain_DT)
    stock_Risk_Train_DT[f] = 1 - stock_Accuracy_Train_DT[f]  # Calcul du risque
    stock_ConfMat_Train_DT[f, :, :] = confusion_matrix(YRTrain, YhatTrain_DT)

    # Prediction sur les échantillons de test
    YhatVal_DT = DT_model.predict(XVal)
    stock_Accuracy_Val_DT[f] = accuracy_score(YRVal, YhatVal_DT)
    stock_Risk_Val_DT[f] = 1 - stock_Accuracy_Val_DT[f]  # Calcul du risque
    stock_ConfMat_Val_DT[f, :, :] = confusion_matrix(YRVal, YhatVal_DT)

    f = f + 1

# Graphique de l'évolution (Average Risk)
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
sns.barplot(x=np.arange(nbFolds), y=stock_Risk_Train_DT, color='blue', ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Average Risk -Training set ')
plt.xlabel('Fold')
plt.ylabel('Average risk')

plt.subplot(1, 2, 2)
sns.barplot(x=np.arange(nbFolds), y=stock_Risk_Val_DT, color='orange')
plt.title('Average Risk -Validation set ')
plt.xlabel('Fold')
plt.ylabel('Average Risk')

plt.tight_layout()
plt.show()

# Graphique de l'évolution (Average Accuracy)
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
sns.barplot(x=np.arange(nbFolds), y=stock_Accuracy_Train_DT, color='blue', ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Average Accuracy - Training set')
plt.xlabel('Fold')
plt.ylabel('Average Accuracy')

plt.subplot(1, 2, 2)
sns.barplot(x=np.arange(nbFolds), y=stock_Accuracy_Val_DT, color='orange')
plt.title('Average Accuracy - Validation set')
plt.xlabel('Fold')
plt.ylabel('Average Accuracy')

plt.tight_layout()
plt.show()

# Affichage des matrices de confusion en pourcentages
labels = ['Class ' + str(i + 1) for i in range(K)]
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
conf_mat_train_avg = np.mean(stock_ConfMat_Train_DT, axis=0)
conf_mat_train_avg_percent = conf_mat_train_avg / conf_mat_train_avg.sum(axis=1, keepdims=True)
sns.heatmap(conf_mat_train_avg_percent, annot=True, fmt=".2f")
plt.title('Average Confusion Matrix - Training Set')

plt.subplot(1, 2, 2)
conf_mat_val_avg = np.mean(stock_ConfMat_Val_DT, axis=0)
conf_mat_val_avg_percent = conf_mat_val_avg / conf_mat_val_avg.sum(axis=1, keepdims=True)
sns.heatmap(conf_mat_val_avg_percent, annot=True, fmt=".2f")
plt.title('Average Confusion Matrix - Validation Set')

plt.tight_layout()
plt.show()


from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
import numpy as np
from sklearn.tree import plot_tree, export_text
from sklearn.tree import export_graphviz, plot_tree
from sklearn import tree
import graphviz


model_rf = RandomForestClassifier(n_estimators=100, criterion='gini', max_depth=5, random_state=0)
model_rf.fit(X_train, y_train)

# Prédictions sur les données de test
predictions_rf = model_rf.predict(X_test)
accuracy_rf = accuracy_score(y_test, predictions_rf)
conf_matrix_rf = confusion_matrix(y_test, predictions_rf)

print(f'Accuracy du modèle Random Forest: {accuracy_rf:.2f}')

# Appliquer le t-SNE pour réduire à 2 dimensions
tsne = TSNE(n_components=2)
X_tsne_rf = tsne.fit_transform(X_train)


model_rf.fit(X_tsne_rf, y_train)

# Tracer les points de données
plt.figure(figsize=(12, 8))

plt.scatter(X_tsne_rf[:, 0], X_tsne_rf[:, 1], c=y_train, cmap='bwr', marker='o', label='Données d\'entraînement')

# Tracer la frontière de décision avec des couleurs de fond
h = .02
x_min, x_max = X_tsne_rf[:, 0].min() - 1, X_tsne_rf[:, 0].max() + 1
y_min, y_max = X_tsne_rf[:, 1].min() - 1, X_tsne_rf[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
Z = model_rf.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

# Ajouter des couleurs de fond
plt.contourf(xx, yy, Z, cmap='bwr', alpha=0.3)

# Création d'une légende personnaliséee
classes = ["Mort", "Survivant"]
legend_labels = {i: label for i, label in enumerate(classes)}
scatter_legend = plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='red', markersize=10, label=legend_labels[1])
contour_legend = plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='blue', markersize=10, label=legend_labels[0])
plt.legend(handles=[scatter_legend, contour_legend])

plt.title('Random Forest avec t-SNE (Données d\'entraînement)')
plt.xlabel('X 1')
plt.ylabel('X 2')
plt.show()

# Affichage d'un arbre de la forêt (ici le premier arbre)
tree = model_rf.estimators_[0]
plot_tree(tree, filled=True, class_names=['Mort', 'Survivant'], feature_names=['Feature 1', 'Feature 2'])

# Récupération du premier arbre de Random Forest
tree_rf = model_rf.estimators_[0]

# Visualiser l'arbre avec graphviz
dot_data_rf = export_graphviz(tree_rf, out_file=None,
                              filled=True, rounded=True,
                              special_characters=True,
                              class_names=['Mort', 'Survivant'],
                              feature_names=['Feature 1', 'Feature 2'])

graph_rf = graphviz.Source(dot_data_rf)
graph_rf.render("RandomForest_Tree")

# afficher quand meme sur l'interface
graph_rf.view()


plt.show()

Accuracy du modèle Random Forest: 0.81


from sklearn.ensemble import RandomForestClassifier

np.random.seed(407)

y_train = y_train.ravel() + 1

K = 2

nbFolds = 10
kf = KFold(n_splits=nbFolds, shuffle=True)
kfSplit = kf.split(X_train)

# Initialisation des tableaux pour stocker les résultats de chaque fold
stock_average_risk_Train_rf = np.zeros((nbFolds, 1))
stock_average_risk_Val_rf = np.zeros((nbFolds, 1))

stock_RiskPerClass_Train_rf = np.zeros((nbFolds, K))
stock_RiskPerClass_Val_rf = np.zeros((nbFolds, K))

stock_Accuracy_Train_rf = np.zeros(nbFolds)
stock_Accuracy_Val_rf = np.zeros(nbFolds)

stock_AccPerClass_Train_rf = np.zeros((nbFolds, K))
stock_AccPerClass_Val_rf = np.zeros((nbFolds, K))

stock_ConfMat_Train_rf = np.zeros((nbFolds, K, K))
stock_ConfMat_Val_rf = np.zeros((nbFolds, K, K))

f = 0

# Boucle sur les folds
for train, val in kfSplit:
    XTrain, XVal, YRTrain, YRVal = X_train[train, :], X_train[val, :], y_train[train], y_train[val]

    # Entraîner le modèle Random Forest
    model_rf = RandomForestClassifier(n_estimators=100, criterion='gini', max_depth=5, random_state=0)
    model_rf.fit(XTrain, YRTrain)

    # Prédiction sur les données d'entraînement
    YhatTrain_rf = model_rf.predict(XTrain)
    stock_average_risk_Train_rf[f, 0] = 1 - accuracy_score(YRTrain, YhatTrain_rf)
    stock_RiskPerClass_Train_rf[f, :] = 1 - np.array([accuracy_score(YRTrain[YRTrain == 0], YhatTrain_rf[YRTrain == 0]),
                                                     accuracy_score(YRTrain[YRTrain == 1], YhatTrain_rf[YRTrain == 1])])
    stock_Accuracy_Train_rf[f] = accuracy_score(YRTrain, YhatTrain_rf)
    stock_AccPerClass_Train_rf[f, :] = np.array([accuracy_score(YRTrain[YRTrain == 0], YhatTrain_rf[YRTrain == 0]),
                                                 accuracy_score(YRTrain[YRTrain == 1], YhatTrain_rf[YRTrain == 1])])
    stock_ConfMat_Train_rf[f, :, :] = confusion_matrix(YRTrain, YhatTrain_rf)

    # Prédiction sur les données de validation
    YhatVal_rf = model_rf.predict(XVal)
    stock_average_risk_Val_rf[f, 0] = 1 - accuracy_score(YRVal, YhatVal_rf)
    stock_RiskPerClass_Val_rf[f, :] = 1 - np.array([accuracy_score(YRVal[YRVal == 0], YhatVal_rf[YRVal == 0]),
                                                   accuracy_score(YRVal[YRVal == 1], YhatVal_rf[YRVal == 1])])
    stock_Accuracy_Val_rf[f] = accuracy_score(YRVal, YhatVal_rf)
    stock_AccPerClass_Val_rf[f, :] = np.array([accuracy_score(YRVal[YRVal == 0], YhatVal_rf[YRVal == 0]),
                                               accuracy_score(YRVal[YRVal == 1], YhatVal_rf[YRVal == 1])])
    stock_ConfMat_Val_rf[f, :, :] = confusion_matrix(YRVal, YhatVal_rf)

    f = f + 1



# plot average risk
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
sns.barplot(x=np.arange(nbFolds), y=stock_average_risk_Train_rf.ravel(), color='blue', ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Average Risk - Training Set')
plt.xlabel('Fold')
plt.ylabel('Average Risk')

plt.subplot(1, 2, 2)
sns.barplot(x=np.arange(nbFolds), y=stock_average_risk_Val_rf.ravel(), color='orange')
plt.title('Average Risk - Validation Set')
plt.xlabel('Fold')
plt.ylabel('Average Risk')

plt.tight_layout()
plt.show()

# plot average accuracy avec la moyenne de tout les fold
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
sns.barplot(x=np.arange(nbFolds), y=stock_Accuracy_Train_rf, color='blue', ci='sd', errwidth=1, capsize=0.1, errcolor='black', edgecolor='black', linewidth=1)
plt.title('Average Accuracy - Training Set')
plt.xlabel('Fold')
plt.ylabel('Average Accuracy')

plt.subplot(1, 2, 2)
sns.barplot(x=np.arange(nbFolds), y=stock_Accuracy_Val_rf, color='orange')
plt.title('Average Accuracy - Validation Set')
plt.xlabel('Fold')
plt.ylabel('Average Accuracy')

plt.tight_layout()
plt.show()

# Affichage des matrices de confusion en pourcentages
labels = ['Class ' + str(i + 1) for i in range(K)]
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
conf_mat_train_avg = np.mean(stock_ConfMat_Train_rf, axis=0)
conf_mat_train_avg_percent = conf_mat_train_avg / conf_mat_train_avg.sum(axis=1, keepdims=True)
sns.heatmap(conf_mat_train_avg_percent, annot=True, fmt=".2f")
plt.title('Average Confusion Matrix - Training Set')

plt.subplot(1, 2, 2)
conf_mat_val_avg = np.mean(stock_ConfMat_Val_rf, axis=0)
conf_mat_val_avg_percent = conf_mat_val_avg / conf_mat_val_avg.sum(axis=1, keepdims=True)
sns.heatmap(conf_mat_val_avg_percent, annot=True, fmt=".2f")
plt.title('Average Confusion Matrix - Validation Set')

plt.tight_layout()
plt.show()


import tensorflow as tf

nbFolds = 10
skf = StratifiedKFold(n_splits=nbFolds, shuffle=True, random_state=407)


y_train = y_train.ravel() - 1

# Définir l'architecture du réseau neuronal
model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', input_shape=(X_train.shape[1],)),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])


history_list = []
accuracy_list_train_RN = []
accuracy_list_val_RN = []
conf_matrix_list = []
conf_mat_train_avg = []
conf_mat_val_avg = []


for fold, (train_idx, val_idx) in enumerate(skf.split(X_train, y_train)):
    XTrain, XVal = X_train[train_idx, :], X_train[val_idx, :]
    YRTrain, YRVal = y_train[train_idx], y_train[val_idx]

    # Entraînement du modèle
    history = model.fit(XTrain, YRTrain, epochs=100, batch_size=32, validation_data=(XVal, YRVal), verbose=0)

    # Évaluation du modèle sur l'ensemble d'apprentissage
    _, accuracy_train = model.evaluate(XTrain, YRTrain)
    accuracy_list_train_RN.append(accuracy_train)

    y_prob = model.predict(XTrain)
    threshold = 0.5
    y_pred = (y_prob > threshold).astype(int)

    y_pred = np.array(y_pred).flatten()

    conf_matrix = confusion_matrix(YRTrain, y_pred, normalize='true') * 100
    conf_mat_train_avg.append(conf_matrix)

    # Évaluation du modèle sur l'ensemble de validation
    _, accuracy_val = model.evaluate(XVal, YRVal)
    accuracy_list_val_RN.append(accuracy_val)

    y_prob = model.predict(XVal)
    threshold = 0.5
    y_pred = (y_prob > threshold).astype(int)

    y_pred = np.array(y_pred).flatten()

    conf_matrix = confusion_matrix(YRVal, y_pred, normalize='true') * 100
    conf_mat_val_avg.append(conf_matrix)

    history_list.append(history)



plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
sns.barplot(x=np.arange(nbFolds), y=accuracy_list_train_RN, color='blue')
plt.title(f"Acurracy moyenne de l'apprentissage: {np.mean(accuracy_list_train_RN) * 100:.2f}%")
plt.xlabel('Fold')
plt.ylabel('Acurracy')

plt.subplot(1, 2, 2)
sns.barplot(x=np.arange(nbFolds), y=accuracy_list_val_RN, color='orange')
plt.title(f'Acurracy moyenne de la validation: {np.mean(accuracy_list_val_RN) * 100:.2f}%')
plt.xlabel('Fold')
plt.ylabel('Acurracy')

plt.tight_layout()
plt.show()

# Affichage des matrices de confusion en pourcentages
labels = ['Class ' + str(i + 1) for i in range(K)]
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
conf_mat_train_avg = np.mean(conf_mat_train_avg, axis=0)
sns.heatmap(conf_mat_train_avg, annot=True, fmt=".2f")
plt.title('Matrice de Confusion Moyenne - Apprentissage')

plt.subplot(1, 2, 2)
conf_mat_val_avg = np.mean(conf_mat_val_avg, axis=0)
sns.heatmap(conf_mat_val_avg, annot=True, fmt=".2f")
plt.title('Matrice de Confusion Moyenne - Validation')

plt.tight_layout()
plt.show()

18/18 [==============================] - 0s 2ms/step - loss: 0.3792 - accuracy: 0.8482
18/18 [==============================] - 0s 1ms/step
2/2 [==============================] - 0s 8ms/step - loss: 0.3658 - accuracy: 0.8413
2/2 [==============================] - 0s 4ms/step
18/18 [==============================] - 0s 2ms/step - loss: 0.3335 - accuracy: 0.8696
18/18 [==============================] - 0s 2ms/step
2/2 [==============================] - 0s 7ms/step - loss: 0.5705 - accuracy: 0.7778
2/2 [==============================] - 0s 6ms/step
18/18 [==============================] - 0s 2ms/step - loss: 0.3300 - accuracy: 0.8679
18/18 [==============================] - 0s 2ms/step
2/2 [==============================] - 0s 7ms/step - loss: 0.3916 - accuracy: 0.8413
2/2 [==============================] - 0s 5ms/step
18/18 [==============================] - 0s 2ms/step - loss: 0.3203 - accuracy: 0.8627
18/18 [==============================] - 0s 1ms/step
2/2 [==============================] - 0s 6ms/step - loss: 0.3573 - accuracy: 0.8710
2/2 [==============================] - 0s 5ms/step
18/18 [==============================] - 0s 2ms/step - loss: 0.3046 - accuracy: 0.8734
18/18 [==============================] - 0s 2ms/step
2/2 [==============================] - 0s 15ms/step - loss: 0.4038 - accuracy: 0.8548
2/2 [==============================] - 0s 18ms/step
18/18 [==============================] - 0s 2ms/step - loss: 0.2963 - accuracy: 0.8681
18/18 [==============================] - 0s 1ms/step
2/2 [==============================] - 0s 6ms/step - loss: 0.3869 - accuracy: 0.8387
2/2 [==============================] - 0s 5ms/step
18/18 [==============================] - 0s 2ms/step - loss: 0.2886 - accuracy: 0.8824
18/18 [==============================] - 0s 1ms/step
2/2 [==============================] - 0s 7ms/step - loss: 0.4100 - accuracy: 0.8226
2/2 [==============================] - 0s 4ms/step
18/18 [==============================] - 0s 2ms/step - loss: 0.2905 - accuracy: 0.8806
18/18 [==============================] - 0s 2ms/step
2/2 [==============================] - 0s 7ms/step - loss: 0.3039 - accuracy: 0.8710
2/2 [==============================] - 0s 4ms/step
18/18 [==============================] - 0s 2ms/step - loss: 0.2818 - accuracy: 0.8824
18/18 [==============================] - 0s 1ms/step
2/2 [==============================] - 0s 7ms/step - loss: 0.3534 - accuracy: 0.8871
2/2 [==============================] - 0s 5ms/step
18/18 [==============================] - 0s 2ms/step - loss: 0.2788 - accuracy: 0.8895
18/18 [==============================] - 0s 1ms/step
2/2 [==============================] - 0s 7ms/step - loss: 0.3236 - accuracy: 0.8387
2/2 [==============================] - 0s 5ms/step


from sklearn.cluster import KMeans


tsne = TSNE(n_components=2)
X_tsne = tsne.fit_transform(X_train)

# Configurer le modèle K-Means
kmeans = KMeans(n_clusters=5, init='k-means++', max_iter=100, random_state=42)

# Initialiser une liste pour stocker les inerties à chaque itération
inertias = []

# Entraîner le K-Means et enregistrer l'inertie à chaque itération
for i in range(1, 21):
    kmeans.set_params(n_init=1, max_iter=i)
    kmeans.fit(X_train)
    inertias.append(kmeans.inertia_)

# Tracer le graphique de convergence à l'aide de Seaborn
plt.figure(figsize=(10, 6))
sns.lineplot(x=range(1, 21), y=inertias, marker='o')
plt.title('Convergence du K-Means')
plt.xlabel('Nombre d\'Itérations')
plt.ylabel('Inertie')
plt.show()

predictions_kmeans = kmeans.predict(X_train)

plt.figure(figsize=(12, 8))
sns.scatterplot(x=X_tsne[:, 0], y=X_tsne[:, 1], hue=predictions_kmeans, palette='tab10', marker='o', legend=False)

plt.title('K-Means avec t-SNE')
plt.xlabel('Dimension t-SNE 1')
plt.ylabel('Dimension t-SNE 2')
plt.legend()
plt.show()

WARNING:matplotlib.legend:No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.


from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_samples, silhouette_score

# Appliquer le t-SNE pour réduire à 2 dimensions
tsne = TSNE(n_components=2)
X_tsne = tsne.fit_transform(X_train)

# Trouver le nombre optimal de clusters en utilisant le coefficient de Silhouette
silhouette_scores = []
for k in range(2, 11):
    kmeans = KMeans(n_clusters=k, init='k-means++', random_state=42)
    kmeans.fit(X_train)
    predictions = kmeans.predict(X_train)
    silhouette_avg = silhouette_score(X_train, predictions)
    silhouette_scores.append(silhouette_avg)

# Tracer le graphique de Silhouette pour déterminer le nombre optimal de clusters
plt.figure(figsize=(10, 6))
sns.lineplot(x=range(2, 11), y=silhouette_scores, marker='o')
plt.title('Coefficient Silhouette pour Déterminer le Nombre de Clusters')
plt.xlabel('Nombre de Clusters (K)')
plt.ylabel('Coefficient Silhouette Moyen')
plt.show()

# Choisir le nombre de clusters avec le plus grand coefficient de Silhouette
optimal_k = silhouette_scores.index(max(silhouette_scores)) + 2  # +2 parce que nous commençons avec k=2
print(f'Nombre idéal de clusters (K) avec Silhouette : {optimal_k}')

tsne = TSNE(n_components=2)
X_tsne = tsne.fit_transform(X_train)

# Configurer K-Means avec le nombre optimal de clusters
kmeans = KMeans(n_clusters=optimal_k, init='k-means++', max_iter=100, random_state=42)
kmeans.fit(X_train)

predictions_kmeans = kmeans.predict(X_train)

# Tracer les points de données avec seaborn
plt.figure(figsize=(12, 8))
sns.scatterplot(x=X_tsne[:, 0], y=X_tsne[:, 1], hue=predictions_kmeans, palette='tab10', marker='o', legend=False)

plt.title('K-Means avec t-SNE (Nombre de Clusters = {})'.format(optimal_k))
plt.xlabel('Dimension t-SNE 1')
plt.ylabel('Dimension t-SNE 2')
plt.legend()
plt.show()

# Configurer K-Means avec le nombre optimal de clusters
kmeans = KMeans(n_clusters=optimal_k, init='k-means++', max_iter=100, random_state=42)
kmeans.fit(X_train)


predictions_kmeans = kmeans.predict(X_train)

# Calculer le coefficient Silhouette pour chaque observation
silhouette_values = silhouette_samples(X_train, predictions_kmeans)

# Tracer le graphique de Silhouette pour chaque observation
plt.figure(figsize=(12, 8))
y_lower = 10
for i in range(optimal_k):
    # Agréger les valeurs Silhouette pour les clusters individuels
    cluster_silhouette_values = silhouette_values[predictions_kmeans == i]
    cluster_silhouette_values.sort()

    y_upper = y_lower + len(cluster_silhouette_values)

    color = sns.color_palette('tab10')[i]

    # Remplir la zone entre y_lower et y_upper avec la couleur du cluster
    plt.fill_betweenx(y=np.arange(y_lower, y_upper), x1=0, x2=cluster_silhouette_values, color=color, alpha=0.7)

    # Étiquettes pour indiquer la valeur moyenne de Silhouette dans chaque cluster
    plt.text(-0.05, y_lower + 0.5 * len(cluster_silhouette_values), str(i))

    y_lower = y_upper + 10

plt.title('Graphique de Silhouette pour Clusters ')
plt.xlabel('Coefficient Silhouette')
plt.ylabel('Cluster')
plt.show()

Nombre idéal de clusters (K) avec Silhouette : 2

WARNING:matplotlib.legend:No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.


# Boxplots for Accuracy Comparison
plt.figure(figsize=(18, 7))

# Boxplot for KNN
plt.subplot(1, 6, 1)
sns.boxplot(data=[stock_Accuracy_Train, stock_Accuracy_Val], palette=['blue', 'orange'])
plt.title('KNN')
plt.xticks([0, 1], ['Training', 'Validation'])
plt.ylabel('Accuracy')

# Boxplot for Bayes
plt.subplot(1, 6, 2)
sns.boxplot(data=[stock_Accuracy_Train_bayes.ravel(), stock_Accuracy_Val_bayes.ravel()], palette=['blue', 'orange'])
plt.title('Bayes')
plt.xticks([0, 1], ['Training', 'Validation'])
plt.ylabel('Accuracy')

# Boxplot for Logistic Regression
plt.subplot(1, 6, 3)
sns.boxplot(data=[stock_Accuracy_Train_rl.ravel(), stock_Accuracy_Val_rl.ravel()], palette=['blue', 'orange'])
plt.title('Logistic Regression')
plt.xticks([0, 1], ['Training', 'Validation'])
plt.ylabel('Accuracy')

# Boxplot for Random Forest
plt.subplot(1, 6, 4)
sns.boxplot(data=[stock_Accuracy_Train_rf.ravel(), stock_Accuracy_Val_rf.ravel()], palette=['blue', 'orange'])
plt.title('Random Forest')
plt.xticks([0, 1], ['Training', 'Validation'])
plt.ylabel('Accuracy')

# Boxplot for Decision Tree
plt.subplot(1, 6, 5)
sns.boxplot(data=[stock_Accuracy_Train_DT.ravel(), stock_Accuracy_Val_DT.ravel()], palette=['blue', 'orange'])
plt.title('Decision Tree')
plt.xticks([0, 1], ['Training', 'Validation'])
plt.ylabel('Accuracy')

# Boxplot for Reseau de neurone
plt.subplot(1, 6, 6)
sns.boxplot(data=[accuracy_list_train_RN, accuracy_list_val_RN], palette=['blue', 'orange'])
plt.title('Reseau de neurone')
plt.xticks([0, 1], ['Training', 'Validation'])
plt.ylabel('Accuracy')

plt.tight_layout(w_pad=2)
plt.show()


from sklearn.naive_bayes import GaussianNB


model_bayes = GaussianNB()
model_bayes.fit(X_train, y_train)

# Prédire les données de test
predictions_bayes = model_bayes.predict(X_test)
accuracy_bayes = accuracy_score(y_test, predictions_bayes)
conf_matrix_bayes = confusion_matrix(y_test, predictions_bayes)

# Apliquer le TSNE pour réduire à 2 dimensions
tsne = TSNE(n_components=2)
X_tsne = tsne.fit_transform(X)


model_bayes.fit(X_tsne, y)
predictions_bayes_tsne = model_bayes.predict(X_tsne)
accuracy_bayes_tsne = accuracy_score(y, predictions_bayes_tsne)
conf_matrix_bayes_tsne = confusion_matrix(y, predictions_bayes_tsne)


plt.figure(figsize=(10, 8))


sns.scatterplot(x=X_tsne[:, 0], y=X_tsne[:, 1], hue=predictions_bayes_tsne, palette='bwr', marker='o', legend=False)

# Afficher les frontières de décision
h = .02
x_min, x_max = X_tsne[:, 0].min() - 1, X_tsne[:, 0].max() + 1
y_min, y_max = X_tsne[:, 1].min() - 1, X_tsne[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
Z = model_bayes.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, cmap='bwr', alpha=0.3)

label2 = ['Mort' if label == 0 else 'Survivant' for label in y]
unique_labels = list(set(label2))
legend_labels = ['Mort' if label == unique_labels[0] else 'Survivant' for label in label2]

colors = {'Mort': 'blue', 'Survivant': 'red'}
legend_patches = [mpatches.Patch(color=colors[label], label=label) for label in set(legend_labels)]

legend = Legend(plt.gca(), legend_patches, labels=set(legend_labels), loc='upper right')
plt.gca().add_artist(legend)

plt.title(f'Bayes Naif avec t-SNE avec une précision de {accuracy_bayes_tsne:.2f}')
plt.xlabel('X 1')
plt.ylabel('X 2')
plt.show()

Variable	Description
survival	Survival (0 = No; 1 = Yes)
pclass	Passenger Class (1 = 1st; 2 = 2nd; 3 = 3rd)
name	Name
sex	Sex
age	Age
sibsp	Number of Siblings/Spouses Aboard
parch	Number of Parents/Children Aboard
ticket	Ticket Number
fare	Passenger Fare
cabin	Cabin
embarked	Port of Embarkation (C = Cherbourg; Q = Queenstown; S = Southampton)

	PassengerId	Survived	Pclass	Name	Sex	Age	SibSp	Ticket	Fare	Cabin	Embarked
0	1	0	3	Braund, Mr. Owen Harris	male	22.0	1	A/5 21171	7.2500	NaN	S
1	2	1	1	Cumings, Mrs. John Bradley (Florence Briggs Th...	female	38.0	1	PC 17599	71.2833	C85	C
2	3	1	3	Heikkinen, Miss. Laina	female	26.0	0	STON/O2. 3101282	7.9250	NaN	S
3	4	1	1	Futrelle, Mrs. Jacques Heath (Lily May Peel)	female	35.0	1	113803	53.1000	C123	S
4	5	0	3	Allen, Mr. William Henry	male	35.0	0	373450	8.0500	NaN	S

	PassengerId	Survived	Pclass	Age	SibSp	Parch	Fare
count	891.000000	891.000000	891.000000	714.000000	891.000000	891.000000	891.000000
mean	446.000000	0.383838	2.308642	29.699118	0.523008	0.381594	32.204208
std	257.353842	0.486592	0.836071	14.526497	1.102743	0.806057	49.693429
min	1.000000	0.000000	1.000000	0.420000	0.000000	0.000000	0.000000
25%	223.500000	0.000000	2.000000	20.125000	0.000000	0.000000	7.910400
50%	446.000000	0.000000	3.000000	28.000000	0.000000	0.000000	14.454200
75%	668.500000	1.000000	3.000000	38.000000	1.000000	0.000000	31.000000
max	891.000000	1.000000	3.000000	80.000000	8.000000	6.000000	512.329200

	Survived	Pclass	Age	SibSp	Fare	Sex_female	Sex_male	Embarked_C	Embarked_S
0	0	3	22.0	1	7.2500	0	1	0	1
1	1	1	38.0	1	71.2833	1	0	1	0
2	1	3	26.0	0	7.9250	1	0	0	1
3	1	1	35.0	1	53.1000	1	0	0	1
4	0	3	35.0	0	8.0500	0	1	0	1

	Survived	Pclass	SibSp	Sex_female	Sex_male	Embarked_C	Embarked_S	Age	Fare
0	0	3	1	0	1	0	1	-0.565736	-0.502445
1	1	1	1	1	0	1	0	0.663861	0.786845
2	1	3	0	1	0	0	1	-0.258337	-0.488854
3	1	1	1	1	0	0	1	0.433312	0.420730
4	0	3	0	0	1	0	1	0.433312	-0.486337

ML01: Projet Titanic

Introduction¶

Imports des Librairies¶

Visualisation des données¶

Prétraitement des données¶

Visualisation des points dans un espace en deux dimensions¶

Lasso¶

Ridge¶

K-Nearest-Neighbours (KNN)¶

Analyse des résultats KNN¶

Classifieur de Bayes Naïf CNB¶

Classifieur Regression Logistique¶

Classifieur Arbre de décision¶

Arbre de décision avec critère d'arrêt: alpha¶

Arbre de décision avec critère de Gini¶

Validation croisée sans critère¶

Random Forest¶

Réseau de neurones¶

Classifieur Non Supervisé - K Means¶

Analyse du meilleur classifieur¶

Analyse des Résultats des Classifieurs¶

Choix Final¶